#!/usr/bin/env node

import { EcommerceAutomationApp } from './app.js';
import { platformConfig, notificationConfig, cronConfig, statisticsAccounts } from './config/index.js';
import { accountsConfig } from './config/accounts.js';
import statisticsService from './services/statistics.js';
import { logInfo, logError } from './logger.js';
import fs from 'fs';

function printHelp() {
  const pkg = JSON.parse(fs.readFileSync('./package.json', 'utf-8'));
  console.log('可用命令（package.json scripts）：');
  Object.entries(pkg.scripts).forEach(([name, cmd]) => {
    // 只显示 src/cli.js 相关命令
    if (cmd.includes('src/cli.js')) {
      let example = cmd.replace('node src/cli.js', 'npm run ' + name);
      // 账户 key 用法提示
      if (/refunds|exchange|test/.test(name)) {
        example += ' [账户key]';
      }
      console.log('  ' + example);
    }
  });
  console.log('\n如未指定账户key，则默认使用第一个账户。');
  console.log('更多用法请参考 package.json scripts 或文档。');
}

async function main() {
  let args = process.argv.slice(2);
  if (args.length === 0 || args[0] === 'help') {
    printHelp();
    return;
  }

  // 自动修正参数顺序（如用户输入 <动作> <平台>，则调整为 <平台> <动作>）
  const platformNames = Object.keys(accountsConfig);
  if (args.length >= 2 && !platformNames.includes(args[0]) && platformNames.includes(args[1])) {
    // 交换参数顺序
    args = [args[1], args[0], ...args.slice(2)];
  }

  const [platform, action = 'default', inputAccountKey] = args;

  // 获取账户列表和默认账户 key
  const accountList = accountsConfig[platform] || [];
  const defaultAccountKey = accountList.length > 0 ? accountList[0].key : undefined;
  const accountKey = inputAccountKey || defaultAccountKey;

  logInfo(`命令行参数: ${JSON.stringify(args)}`);
  logInfo(`正在执行命令: 平台: ${platform}, 动作: ${action}, 账户: ${accountKey}`);

  // 定时任务状态
  if (platform === 'cron' && action === 'status') {
    console.log('定时任务状态:');
    for (const [name, config] of Object.entries(cronConfig)) {
      console.log(`${name}: 启用: ${config.enabled ? '是' : '否'} Cron: ${config.cron} 命令: ${config.command}`);
    }
    return;
  }

  // 统计命令
  if (platform === 'statistics') {
    if (action !== 'refunds') {
      printHelp();
      return;
    }
    let startTime, endTime;
    if (args[2] && args[3]) {
      startTime = args[2];
      endTime = args[3];
    } else {
      const { startTime: defaultStart, endTime: defaultEnd } = calculateTimeRange(
        cronConfig.refundStatistics.timeRange.start,
        cronConfig.refundStatistics.timeRange.end
      );
      startTime = defaultStart;
      endTime = defaultEnd;
    }
    try {
      logInfo(`正在统计 ${startTime} 到 ${endTime} 期间的退款订单...`);
      const statistics = await statisticsService.getRefundStatistics(statisticsAccounts, startTime, endTime);
      logInfo('统计结果: ' + statisticsService.formatStatistics(statistics));
    } catch (error) {
      logError('统计过程中出错: ' + error);
    }
    return;
  }

  // 平台自动化主流程
  const app = new EcommerceAutomationApp();
  try {
    // 部分命令无需账户（如 shipment、cron、exchange）
    const noAccountPlatforms = ['shipment', 'cron', 'exchange'];
    if (noAccountPlatforms.includes(platform)) {
      if (platform === 'shipment') {
        logInfo('执行所有平台物流报告');
        await app.runShipmentReport();
      } else if (platform === 'exchange') {
        logInfo('执行所有平台换货待处理订单数任务');
        await app.runExchangePendingCountAll();
      } else if (platform === 'cron') {
        logInfo('定时任务相关命令请用 cron status');
      }
      return;
    }
    // 正常平台命令需账户
    await app.init(platform);
    const account = accountList.find(acc => acc.key === accountKey) || accountList[0];
    if (!account) {
      logError(`未找到账户: ${accountKey}`);
      return;
    }
    await app.createContext(platform, account);

    // 平台主流程分发优化
    const platformActions = {
      refunds: async (...params) => {
        logInfo(`执行${platform}退款处理任务`);
        // 确保传递正确的账户信息
        const account = accountList.find(acc => acc.key === accountKey) || accountList[0];
        await app.runRefundProcess(platform, account);
      },
      exchange: async () => {
        logInfo(`执行${platform}换货待处理订单数任务`);
        await app.runExchangePendingCount(platform);
      },
      shipment: async () => {
        logInfo(`${platform}物流报告已整合到统一报告中，请使用 shipment 命令`);
      },
      test: async () => {
        logInfo(`执行${platform}测试方法`);
        await app.runTest(platform);
      }
    };
    if (platformActions[action]) {
      await platformActions[action](...args.slice(4)); // 传递额外参数
    } else {
      logInfo('显示帮助信息');
      printHelp();
    }
  } catch (err) {
    logError('命令执行异常: ' + (err.stack || err));
  } finally {
    await app.close();
  }
}

/**
 * 计算时间范围（复制自 cron.js 中的逻辑）
 * @param {string} start - 开始时间配置
 * @param {string} end - 结束时间配置
 * @returns {Object} 包含格式化开始和结束时间的对象
 */
function calculateTimeRange(start, end) {
  const now = new Date();
  let startTime, endTime;

  // 如果配置的是昨天的完整日期范围
  if (start === '-1d' && end === 'now') {
    // 设置为昨天的00:00:00到今天的00:00:00
    const today = new Date(now);
    today.setHours(0, 0, 0, 0);

    endTime = new Date(today);
    startTime = new Date(today);
    startTime.setDate(startTime.getDate() - 1);
  } else {
    // 原有的时间计算逻辑
    // 解析开始时间
    if (start === 'now') {
      startTime = now;
    } else if (start.startsWith('-')) {
      // 相对时间，例如 -24h, -7d
      const match = start.match(/-(\d+)([a-zA-Z])/);
      if (match) {
        const value = parseInt(match[1]);
        const unit = match[2];

        startTime = new Date(now);
        switch (unit) {
          case 'h': // 小时
            startTime.setHours(startTime.getHours() - value);
            break;
          case 'd': // 天
            startTime.setDate(startTime.getDate() - value);
            break;
          case 'm': // 分钟
            startTime.setMinutes(startTime.getMinutes() - value);
            break;
          default:
            startTime = new Date(now.getTime() - 24 * 60 * 60 * 1000); // 默认24小时前
        }
      } else {
        // 默认24小时前
        startTime = new Date(now.getTime() - 24 * 60 * 60 * 1000);
      }
    } else {
      // 绝对时间，尝试解析
      startTime = new Date(start) || new Date(now.getTime() - 24 * 60 * 60 * 1000);
    }

    // 解析结束时间
    if (end === 'now') {
      endTime = now;
    } else {
      // 尝试解析为绝对时间
      endTime = new Date(end) || now;
    }
  }

  // 格式化为指定的字符串格式
  const formatTime = (date) => {
    const year = date.getFullYear();
    const month = String(date.getMonth() + 1).padStart(2, '0');
    const day = String(date.getDate()).padStart(2, '0');
    const hours = String(date.getHours()).padStart(2, '0');
    const minutes = String(date.getMinutes()).padStart(2, '0');
    const seconds = String(date.getSeconds()).padStart(2, '0');
    return `${year}/${month}/${day} ${hours}:${minutes}:${seconds}`;
  };

  return {
    startTime: formatTime(startTime),
    endTime: formatTime(endTime)
  };
}

main();